{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "读取mnist数据集，保存到mnist变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-155c01462d35>:1: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From C:\\Anaconda\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From C:\\Anaconda\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\Anaconda\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\Anaconda\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\Anaconda\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784)\n",
      "(55000, 10)\n",
      "(5000, 784)\n",
      "(5000, 10)\n",
      "(10000, 784)\n",
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets(\"./\", one_hot=True)\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#定义一个8*8大小的画布\n",
    "plt.figure(figsize=(8, 8))\n",
    "\n",
    "for idx in range(16):\n",
    "    #在画布里按4行4列画出16个子图\n",
    "    plt.subplot(4, 4, idx + 1)\n",
    "    #关闭坐标轴\n",
    "    plt.axis('off')\n",
    "    #设置标题\n",
    "    plt.title('[{}]'.format(np.argmax(mnist.train.labels[idx])))\n",
    "    #显示图片，将一维图片还原成28*28的二维图片\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28, 28)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义训练模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![avatar](./Mnist_Lecun.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义输入\n",
    "因为输入28*28的图片，图片转换成一维向量表示，因此是784.None表示的是batch_size,这里未定义，因此给none\n",
    "\n",
    "对于输出，最终输出的是10个数字。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.placeholder(\"float\", [None, 784], name='x')\n",
    "y = tf.placeholder(\"float\", [None, 10], name='y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为输入的是图片展开后的一维向量，因此需要吧图片进行还原，还原为二维图片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_image = tf.reshape(x, [-1, 28, 28, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义第一层卷积层，使用6个5* 5的卷积核进行卷积，padding方式选择vaild（即不需要外围补像素），输出为24* 24，深度从原来的1变成6.激活函数为 rule函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n"
     ]
    }
   ],
   "source": [
    "#在conv1这一个命名空间中进行变量定义\n",
    "with tf.name_scope('conv1'):\n",
    "    C1 = tf.contrib.slim.conv2d(\n",
    "        x_image, 6, [5, 5], padding='VALID', activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "而对于tf.contrib.slim.conv2d，其函数定义如下：\n",
    "\n",
    "convolution(inputs,\n",
    "\n",
    "          num_outputs,\n",
    "\n",
    "          kernel_size,\n",
    "\n",
    "          stride=1,\n",
    "\n",
    "          padding='SAME',\n",
    "\n",
    "          data_format=None,\n",
    "\n",
    "          rate=1,\n",
    "\n",
    "          activation_fn=nn.relu,\n",
    "\n",
    "          normalizer_fn=None,\n",
    "\n",
    "          normalizer_params=None,\n",
    "\n",
    "          weights_initializer=initializers.xavier_initializer(),\n",
    "\n",
    "          weights_regularizer=None,\n",
    "\n",
    "          biases_initializer=init_ops.zeros_initializer(),\n",
    "\n",
    "          biases_regularizer=None,\n",
    "\n",
    "          reuse=None,\n",
    "\n",
    "          variables_collections=None,\n",
    "\n",
    "          outputs_collections=None,\n",
    "\n",
    "          trainable=True,\n",
    "\n",
    "          scope=None):\n",
    "\n",
    "inputs同样是指需要做卷积的输入图像\n",
    "\n",
    "num_outputs指定卷积核的个数（就是filter的个数）\n",
    "\n",
    "kernel_size用于指定卷积核的维度（卷积核的宽度，卷积核的高度）\n",
    "\n",
    "stride为卷积时在图像每一维的步长\n",
    "\n",
    "padding为padding的方式选择，VALID或者SAME\n",
    "\n",
    "data_format是用于指定输入的input的格式\n",
    "\n",
    "rate这个参数不是太理解，而且tf.nn.conv2d中也没有，对于使用atrous convolution的膨胀率（不是太懂这个atrous convolution）\n",
    "\n",
    "activation_fn用于激活函数的指定，默认的为ReLU函数\n",
    "\n",
    "normalizer_fn用于指定正则化函数\n",
    "\n",
    "normalizer_params用于指定正则化函数的参数\n",
    "\n",
    "weights_initializer用于指定权重的初始化程序\n",
    "\n",
    "weights_regularizer为权重可选的正则化程序\n",
    "\n",
    "biases_initializer用于指定biase的初始化程序\n",
    "\n",
    "biases_regularizer: biases可选的正则化程序\n",
    "\n",
    "reuse指定是否共享层或者和变量\n",
    "\n",
    "variable_collections指定所有变量的集合列表或者字典\n",
    "\n",
    "outputs_collections指定输出被添加的集合\n",
    "\n",
    "trainable:卷积层的参数是否可被训练\n",
    "\n",
    "scope:共享变量所指的variable_scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义第一个池化层，stride为2(即步长为2），输出深度不变，但长宽减半，输出为12* 12，深度为6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('pool1'):\n",
    "    S2 = tf.contrib.slim.max_pool2d(C1, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义第二个卷积层，使用16个 5* 5的卷积核，padding为vaild，输出为8* 8，深度为16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('conv2'):\n",
    "    C3 = tf.contrib.slim.conv2d(\n",
    "        S2, 16, [5, 5], padding='VALID', activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义第二层池化层，stride为2，输出为4* 4，深度为16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('pool2'):\n",
    "    S4 = tf.contrib.slim.max_pool2d(C3, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "池化后的数据时3维的，需要展开成一维，在送入两个全连接神经网络，分别有120,84个神经元。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Anaconda\\lib\\site-packages\\tensorflow\\contrib\\layers\\python\\layers\\layers.py:1624: flatten (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.flatten instead.\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('fc1'):\n",
    "    S4_flat = tf.contrib.slim.flatten(S4)\n",
    "    C5 = tf.contrib.slim.fully_connected(\n",
    "        S4_flat, 120, activation_fn=tf.nn.relu)\n",
    "\n",
    "with tf.name_scope('fc2'):\n",
    "    F6 = tf.contrib.slim.fully_connected(C5, 84, activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def fully_connected(inputs,\n",
    "                    num_outputs,\n",
    "                    activation_fn=nn.relu,\n",
    "                    normalizer_fn=None,\n",
    "                    normalizer_params=None,\n",
    "                    weights_initializer=initializers.xavier_initializer(),\n",
    "                    weights_regularizer=None,\n",
    "                    biases_initializer=init_ops.zeros_initializer(),\n",
    "                    biases_regularizer=None,\n",
    "                    reuse=None,\n",
    "                    variables_collections=None,\n",
    "                    outputs_collections=None,\n",
    "                    trainable=True,\n",
    "                    scope=None):\n",
    "                    \n",
    "    Args:\n",
    "    inputs: A tensor of at least rank 2 and static value for the last dimension;\n",
    "      i.e. `[batch_size, depth]`, `[None, None, None, channels]`.\n",
    "    num_outputs: Integer or long, the number of output units in the layer.\n",
    "    activation_fn: Activation function. The default value is a ReLU function.\n",
    "      Explicitly set it to None to skip it and maintain a linear activation.\n",
    "    normalizer_fn: Normalization function to use instead of `biases`. If\n",
    "      `normalizer_fn` is provided then `biases_initializer` and\n",
    "      `biases_regularizer` are ignored and `biases` are not created nor added.\n",
    "      default set to None for no normalizer function\n",
    "    normalizer_params: Normalization function parameters.\n",
    "    weights_initializer: An initializer for the weights.\n",
    "    weights_regularizer: Optional regularizer for the weights.\n",
    "    biases_initializer: An initializer for the biases. If None skip biases.\n",
    "    biases_regularizer: Optional regularizer for the biases.\n",
    "    reuse: Whether or not the layer and its variables should be reused. To be\n",
    "      able to reuse the layer scope must be given.\n",
    "    variables_collections: Optional list of collections for all the variables or\n",
    "      a dictionary containing a different list of collections per variable.\n",
    "    outputs_collections: Collection to add the outputs.\n",
    "    trainable: If `True` also add variables to the graph collection\n",
    "      `GraphKeys.TRAINABLE_VARIABLES` (see tf.Variable).\n",
    "    scope: Optional scope for variable_scope."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对特征添加一个0.6的dropout，以40%的概率丢弃特征中的某些数据，\n",
    "这样可以提高网络的推广能力，减少过拟合的可能性。\n",
    "\n",
    "需要注意的是，dropout仅在训练的时候使用，验证的时候，需要关闭dropout， 所以验证时候的keep_prob是1.0。\n",
    "\n",
    "dropout的输出最终送入一个隐层为10的全连接层，这个全连接层即为最后的分类器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-11-413a88f1eb86>:3: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('dropout'):\n",
    "    keep_prob = tf.placeholder(name='keep_prob', dtype=tf.float32)\n",
    "    F6_drop = tf.nn.dropout(F6, keep_prob)\n",
    "\n",
    "with tf.name_scope('fc3'):\n",
    "    logits = tf.contrib.slim.fully_connected(F6_drop, 10, activation_fn=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义训练网络的优化器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-12-185f66705239>:3: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n",
      "\n",
      "Conv/weights:0\n",
      "INFO:tensorflow:Summary name Conv/weights:0 is illegal; using Conv/weights_0 instead.\n",
      "Conv/biases:0\n",
      "INFO:tensorflow:Summary name Conv/biases:0 is illegal; using Conv/biases_0 instead.\n",
      "Conv_1/weights:0\n",
      "INFO:tensorflow:Summary name Conv_1/weights:0 is illegal; using Conv_1/weights_0 instead.\n",
      "Conv_1/biases:0\n",
      "INFO:tensorflow:Summary name Conv_1/biases:0 is illegal; using Conv_1/biases_0 instead.\n",
      "fully_connected/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected/weights:0 is illegal; using fully_connected/weights_0 instead.\n",
      "fully_connected/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected/biases:0 is illegal; using fully_connected/biases_0 instead.\n",
      "fully_connected_1/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/weights:0 is illegal; using fully_connected_1/weights_0 instead.\n",
      "fully_connected_1/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/biases:0 is illegal; using fully_connected_1/biases_0 instead.\n",
      "fully_connected_2/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/weights:0 is illegal; using fully_connected_2/weights_0 instead.\n",
      "fully_connected_2/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/biases:0 is illegal; using fully_connected_2/biases_0 instead.\n"
     ]
    }
   ],
   "source": [
    "#最后一层未经几乎的输出，与label做softmax和求交叉熵损失\n",
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "\n",
    "#设定正则项\n",
    "l2_loss = tf.add_n([\n",
    "    tf.nn.l2_loss(w)\n",
    "    for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n",
    "])\n",
    "\n",
    "for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES):\n",
    "    print(w.name)\n",
    "    tf.summary.histogram(w.name, w)\n",
    "\n",
    "#添加正则项\n",
    "total_loss = cross_entropy_loss + 7e-5 * l2_loss\n",
    "tf.summary.scalar('cross_entropy_loss', cross_entropy_loss)\n",
    "tf.summary.scalar('l2_loss', l2_loss)\n",
    "tf.summary.scalar('total_loss', total_loss)\n",
    "\n",
    "#使用一个梯度下降优化器，学习率设置为0.3\n",
    "optimizer = tf.train.GradientDescentOptimizer(\n",
    "    learning_rate=0.3).minimize(total_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对最后一层的logits输出计算概率分布，然后与laber作比较。随后做一个正确率统计"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = tf.nn.softmax(logits)\n",
    "correct_pred = tf.equal(tf.argmax(y, 1), tf.argmax(logits, 1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义每一批数据的大小及重复训练的次数，sever用于保存和恢复模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "trainig_step = 1100\n",
    "\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.278031, the validation accuracy is 0.9146\n",
      "after 200 training steps, the loss is 0.450708, the validation accuracy is 0.9518\n",
      "after 300 training steps, the loss is 0.179323, the validation accuracy is 0.9602\n",
      "after 400 training steps, the loss is 0.195156, the validation accuracy is 0.9466\n",
      "after 500 training steps, the loss is 0.141867, the validation accuracy is 0.9734\n",
      "after 600 training steps, the loss is 0.0974785, the validation accuracy is 0.9734\n",
      "WARNING:tensorflow:From C:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:966: remove_checkpoint (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to delete files with this prefix.\n",
      "after 700 training steps, the loss is 0.207294, the validation accuracy is 0.9716\n",
      "after 800 training steps, the loss is 0.063217, the validation accuracy is 0.979\n",
      "after 900 training steps, the loss is 0.103864, the validation accuracy is 0.9788\n",
      "after 1000 training steps, the loss is 0.0875005, the validation accuracy is 0.9804\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9824\n"
     ]
    }
   ],
   "source": [
    "merged = tf.summary.merge_all()\n",
    "with tf.Session() as sess:\n",
    "    writer = tf.summary.FileWriter(\"logs/\", sess.graph)\n",
    "    \n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "        keep_prob: 1.0\n",
    "    }\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels, keep_prob: 1.0}\n",
    "\n",
    "    for i in range(trainig_step):\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss, rs = sess.run(\n",
    "            [optimizer, cross_entropy_loss, merged],\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                keep_prob: 0.6\n",
    "            })\n",
    "        writer.add_summary(rs, i)\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-1000\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeEAAAHiCAYAAADf3nSgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3XeYFMXWBvD3bGAJS86SlpxFBTFgAHMWc0CC8ZrTVT8DXjFhuNecURGzqJgDBhQFERAQUKIKSI6Sw7Lsnu+P7u3qGqaX2QnbG97f8+yzp6dqqqunp7umqzqIqoKIiIhKXlrYFSAiIqqo2AgTERGFhI0wERFRSNgIExERhYSNMBERUUjYCBMREYWEjTAREVFIylwjLCJDRCRPRLaISLUY3/OXiOwUkTeKyKMislVE7k9ebUueiHwnIjtEZHzYdYkV12nRyto65fosWllbnwAgIiPc9bMoxvzt3PWfLyKXBOTpLSIFbr7jklrhEiQiWe4y5InIfcV9fyiNsFth/1++iDxVjCJGqmq2qm51y/syorydIvJbYWZVbQ1gaAzldlPVO3z1HCYi89wvyqAoy3GDiKwUkY0iMlxEsnxpOSLyvYhsE5G5InJU0EzdlThcRDa55d3oS2smIhNF5B8ReSTifaNFpIf/NVU9AsDlMSxr0rj1f1lE/haRzSLyq4gcX8xiItfpzSLyu1veQhG52Z+Z6zS1RORqEZkiIrkiMiKOIiLXZx/3s9sYbUfO9Zl6IlJHRD4U54fM3yJyfjGLeFhVc3zlBX4mqjpfVbMBjNtDmcvd78lot8zGIvKJiCwX50dXjj9zUfN004901+U2d922CJpxUevfLWehiKwQkXN8r9cSkWkiUt23rLnusr65h2WNKpRG2P3Qs92KNwSwHcB7CZR3fESZExIpz2cGgCsBTItMEJFjAdwK4EgAOQBaAbjbl+VtAL8CqAvgDgDvi0j9gPkMAdAWQAsAfQDcIuaX4W0AXgXQEkDfwg3a/WIsUNUp8S9e0mQAWALgcAA1AdwJ4N3IDaiYBMAAALUBHAfgahE5N7FqAuA6jdVyAPcBGJ6k8ra6Zd28p4zFxPUZu2cA7ISzz+0H4DkR6ZxAeUMQ/JnEqwDAaABnFHeeIlIPwAdw9j91AEwBMLKIeRW1/h8HcDKcfc9zIpLuvv4AgAdVdXM8CxeVqob6B2AggAUAJMb8QwC8UUR6DoB8AC2L+T4F0CYgbTyAQRGvvQVgqG/6SAAr3bgdgFwA1X3p4wBcHlD+MgDH+KbvBfCOG38JoL0bvwPgbAA14Hx5agWUNwjA+JDX60wAZyRjnbp5ngTwFNdpia/H+wCMKOZ7AtcLgKMALIrne8D1mdB6rAanAW7ne+11OA1KLO8fAeC+WD8T32tjAVwSUGZvAEsD0jLc9Z1TjPVwGYAJEcu8HUCHKOUXuf7h/HgqfH0lgAYAegIYXZzPKJa/0jAmPBDAa+ouBQCIyAYROSTO8gYAGKeqC5NSu2Cd4fwKLzQDQEMRqeumLVD719IM93WLiNQGsFeUsgrz/g7gaBGpBaAHgNlwvniPq+qGJC1LUolIQzhf8lm+1+JepyIiAA71l5ciXKcxSnAbLSlcn0Y7APmqOt/3mrcMItLcXafNYykshs8k6WKYp7W+1RkK+SugTnta/6tFpJuIdINzdL4eztHxtUlYFEuojbC7wg+H05XjUdVaqhrvSQsD4PwiSbVsABt904Vx9ShphenVsbvsiPdH5n0ATgP0A5zupEwAewP4VETeEpEfReTqeBci2UQkE87YyKuqOrfw9QTX6RA439VXEq9hkbhOY5Tg+iwpXJ9Gkcurqovddbq4GOUVlrFbeSmyp3kWd50WlfdyAE8AGAagP4ArAIwBUFlEvnLHkg+PZyEiZSSjkAQMgNMlk5SjVveXeSMA7+8h35dwNhoA+JeqxjOgvgVOl1OhwnhzlLTC9GjjCFt86Tsi86rqPwDOceudBuBHOF+QW+H8Ah8EYJqIfKeqs+NYjqRx6/c6nG6vpOx03J3XAACHqmpuEfm4TssRrs+kK87yxlpeYRm7fSbRiMgW32SnFMyzuOs0MK+qTofTXQ4RaQzgEQAHwfmhdT2ccyZ+FJEW/l7ceITdHT0AEUfBCRoI4ANV3VJUJrVP5IrrjDY4XaPdfNPdAKxS1XVuWiv/GXRu+m7dqaq6HsCKKGVF63q9DMBEVf0dQFcAU1R1J4DfAHSJczmSwu0yfhnOSR9nqGpeEsq8CO6JNaq6tKi8XKflC9dn0s0HkCEibX2vBS3DHhXzMyl8T7bvL9Yj7uLM01rf4lwe1zqgTjGvfwCPARisqtth1ukiOD0eQSfyxSy0RlhEDgbQBMk5ixkiUgXAWUhiV7SIVBKRynDO1M0UkcruL10AeA3AxSLSyR2rGFw4b3fcZTqAu9z3nAane2pUwKxeAzBYRGqLSAcAl0Yuh4g0AHAVnK5ZAFgIoI+IZMMZh1qQhEVOxHMAOgI42f2yJkRE+sG5ZOVoVU3asnGdxkZEMtzPKR1AurvMcfeciUiaW16mMymVRaRSEurJ9RkDd3z0AwD3iEg1EekF4FQ4PVfx2uNnEg93fRZeSpblTscyzw8BdBGRM9z3/AfATP+wWKFY17+IHA2gsqp+5r60EMAR4pxVngVgXaLLWyJn5gWcSfYCgNcD0rbA6X6MljYEUc6gBHAegL8RcJZ10Pt86budeQnnzD6N+OvtS78RwCoAm+CMV2b50nLc928HMA/AUb60fgBm+aaz4Fy+sckt78Yo9XsNwFm+6WYAJsE5YeCRiLyDULJnXrZwP5sd7ror/OsX7zqF82XPiyjvea7TElunQ6J8TkMSWJ+9o5Q3luuzZNanO886AD6Cc7nYYgDn+9Kau+u0ecB7R2D3s6Nj+UzGophnR0dZnxrrPOGcfT/XXadj4Tu7GsDz8O1Dilr/vnlNB9DC99qRABbBOSI/d0+fUUzrpSS/BEn6Ig12v0QbAFSL8T3z3C/Y8CLy7IAzMH9v2MuY4OfzDZxxjTFh14XrtGKuU67P8rU+3Tq/6K6fv2LM39Zd/9sQcemYL89hbgO4AcCxYS9jAp9NlrsMWwHcVdz3i1sIERERlbCwT8wiIiKqsNgIExERhYSNMBERUUhK9GYdR6edxQHokHxT8J4ku0yuz/CkYn0CXKdh4jZavsS6PnkkTEREFBI2wkRERCFhI0xERBQSNsJEREQhYSNMREQUEjbCREREIWEjTEREFBI2wkRERCEp0Zt1EKXCovsO8uL8yva9Cep3XuPFP3cLelQs0Pq7C724+uQqVlrDJyckWkUioqh4JExERBQSNsJEREQhYSNMREQUEo4JU5m0/vO2Xvz7Pk/H9J68Im5lP7fPS178Zo/GVtq73xzuxflz/oixhlSaSPfO1vTnn7zuxV2fv9qLm93L8f+Sll6rphfPe7qVF/u3SQAYvLq7F//Wr52Vlj97fopql3o8EiYiIgoJG2EiIqKQsDuaygR/9zMA/LTPOzG97/kNpnvr0Z+P9uKcFmusfF93+sCL+1VfYaXdP6ieF7f6P3ZHl0Wr969hTe9CvhdXXc5H7oapoGVTL/6t9wteHDl8dF+DqV7c7bSDrbRm7I4mIiKi4mIjTEREFBJ2R1OptetIczbkd92eiUjN9KLH15szJb8/p4edbflqL2y3fooXp1WubGUbOqmrF99e7ze7HrV3xVxnKp3W751vTS/dlevFdV/+uaSrU6FlNGtqTbcc9mdINSkdeCRMREQUEjbCREREIWEjTEREFJIyPSa87tKDrOnm/c3YwtzVDa20nblmDLHJ2yauunSLla9g+uxkVpESsKVJJS9Oi/i96B8HHnuKGc/NXzAvprL/vHtfa/qtOo/4prKstKaj+Vu1LNJe+3jxuJMetdIO//EaL26DX0usThXV4v+YS4q6H2fvYx9uPK7Y5WUfbF9iuOROU369meYcjiofTy522SWNexciIqKQsBEmIiIKSZnujr7l5res6TOqrTcTrYt4Y28TLtq1zUp6Yk2fxCsWo8mrW3hxtUdqWmkZY6ZGZq9war1mLh05c8oFVpqs3+TFu1YsKnbZl5zwrTWdnZYVkJPKqn86VfHixulVrbQm72dGZqcUmvmvp7w4T/OLyBmbsd3etF/oZsIPt5oHsAzf3NfKlvFd6duv8kiYiIgoJGyEiYiIQsJGmIiIKCRlekz4ydvPtab/s7f5TVF7jv0IjvUdxYsr7b3Bix/u8oGV77HGk7z4823ZXnxiVftSpqJs151ePCm3mhf3rpxnZ/TNq805/7KS2o2JeXYVQjIe2r3ofnNJ28W1/heRam5j+e8VB1op1b+dY+qRcC2opBx5pTmn4KOttay07LHmUjau09TIHGvGZjMlPeHyft1Z4MWL8upbaadV+8eLz842t6o9+/VhVr6TmnRHacMjYSIiopCwESYiIgpJme6Orvb+pIjp4Lw1Al5/qlFva/q+XjnmPT+YO3A93LtNzPXK2G66TarNNA+Ir/vjKCtf10q+O3ct4iUTqbChv+mC/mmA6YKumWY/RennXNNdNv0++25aVTaV/rvuEJDeub01PbTB21788ib7yT35GzaWSJ0qku19e1rTFzZ+z4v9lyXFeolSlzGXW9P1x5jLCLM22mXc1tscT/521pOBZS69zdxZq+kDE2KqR6rxSJiIiCgkbISJiIhCUqa7o5Nh18pV1nS1UWba3+FR7f11cZW/6hLTHdq5kv1x/+8f032W88oCu15xzY0ird3PnCUf2QXtN3DsJV7c7iN2P5dFy46uG5g2dXOLiFe2p7YyFYR/COC+R+0zkXtU2unPGViG/w5Xg78/w4s73jLXype/aROCtP/DPNBl8ilmO++ZtcPK9+UVD3vxMZVvsdJyhpq7aWlubuC8ko1HwkRERCFhI0xERBQSNsJEREQhqfBjwqmQ0aKZFz99+9NeHHnXmPeeOMqL6674GZS4nd/YY38/d3jEN2XGirr9PNDK1/Hff3kx76BUNm3qlBeYNv3pfazpWuD2lgwFvvNc7DHgYBf9fZw1vfkc87SrdkvN+RjF2Q79d9S7coS5tGnKvx638jVON/OadrGddsYHZp+gM+agpPBImIiIKCRshImIiELC7ugUmHtDEy/eP8s8OGLWTvuyiDqzt5VYncqzjFY5Xnxvm/estNq+y5Km+q46aHGv3dmVv359SupGqZV7/P5e/PExT1lp96w1N+uvM2qmlVYAKkm3r+rhxZsusS8ly1/6R1LnlTNqrRff2dd+GMuDjX5J6rySgUfCREREIWEjTEREFBJ2RydB7on7W9PTznzMN2VuOn7FdddZ+apM4J2ZkqH1u8u8eN9Kwb8rz/PdEL7djNLXLUXFt/QIswvbu5J9R7SBi7p6cYOt9t2XKPmKembwzP38z3dPbvfzbsQMAWak2QMPRdVx+d0mbtQ36bUKxCNhIiKikLARJiIiCgkbYSIiopBwTDgJFh9v/5bJFjMOfN7Co7246ugZVj4FxWv9QPN0qrsb+u+KlWXlG7jI3JWs4y1/ejHvilU+1O+y2ovz1R7/y/i4dklXp8KZd0VVL87T0rFVLTrdXAL1fn37vJs8TffFdn33usvEJXkJG4+EiYiIQsJGmIiIKCTsjo5TWvXqXtz/0PFW2qYC8yDp1UNbeXFWLi+LiVdGk72s6UOvneTF2WlZkdk9P89u48Xt1vPzLw8yWpqHdPyvvblD2osbm1n56gznQxpSbfChn4Yy34xmTa3pzd3N/uH5C5+NqYzJufYlbbJzV+IViwOPhImIiELCRpiIiCgkbISJiIhCwjHhOP0xpLMXf1bPHoM49Y8zvDjrC45DJsOc2+3xvo8aRR+L6vPbWdY0L0sqf/74lxn/O9B3OsCl0/pY+Zrh95KqEpWw2Xc3sqZnHfN0TO8btaWeFz93k72vqDwnnNsI80iYiIgoJGyEiYiIQsLu6BhtvMB+OPTMc5704r925VlpWx4yp89nYUVqK1ZBTD3lsYhXol+WVPNK+143u9avT1GNKCwFzXZEfX37hspRX6fyIXNsYy9+oPGouMoYsexgL678ael4ih2PhImIiELCRpiIiCgk7I4ugv8uTdffOdJKyxLz0Z07o7+VVv9LnhEdlryGNa3pzJ1Nil1G/pq11rTm5nqxZJlu8PT69RAkv34ta/qPf1eKad6abx5I3uGaP620/E2bYiqjvHv2gDeivt7ky+AHtlNqpIsZ/smU4M9/0/kHBqbdfc/LXtynSvShhsjyd39YRGzrXo9YFlO+ksQjYSIiopCwESYiIgoJG2EiIqKQcEw4gmSYj6TbZ0u9+KzsdVa+Nzc38OKGd9q/ZUrygdBk+/z94QmXcfCv51nTa1fV8OLa9Td78aTubyU8r6J0Gny1Nd3qlor5VKAdJ/e0pg+p7L+0hLuwMD048kwvPvvixwPz/fjfZ7x49/Fc+NJim29RZfh1GXO5Nd0W02KbQQnikTAREVFI2AgTERGFhH05kbq198J7G7wemO2Zoebm37VmVMxuwpJ06ux+1vSYLu+nbF4T9n07rvdt051enKfBgxInzBzkxRunB1/m1GR8OA8ZL20Wn2L3UfovD7xnbVcvzv54qpUvxp5NSkCrkeZyvskX2Hcs65kVfLlRoibn2vMatvJwL15/pXm4Q4eFEZf5paxG8eORMBERUUjYCBMREYWEjTAREVFIKvyYcHqndtb0Ze98HDVfp+FXWdM5r09MWZ1od1WOXWhNdx5qLt/RGL/F1Tv848XFubyo87gLzbwWVwvM1+r9LWZi8m+B+Wrjj6gxGek1zGVh/9fri8B8b315mBe32sVzM0pa/uz5XvyfGy+x0pacbM6LmH/8C0md75XD7UuPmt0/wTdVtp6cxiNhIiKikLARJiIiCkmF746ee2Vta/rkqtGfVNN07E77BeUFEGFqeXtiXY8noXvs88LMhOZFxVfge3LV7G17WWlHLevhxW2HzvLi0nj5SUVS5ePJ1nQ738jeYeeZ4bzMQausfKM7myfUHfP7uV5cMKKBlU/NA8aQM32NlVaW1z2PhImIiELCRpiIiCgkFbI72n9D+DEnPxKRWrVkK0NEu1Ffd/S8HnZaJfztxWW5G7IiqfG272qSiBvSnQazP66GBb6UBQhSntY7j4SJiIhCwkaYiIgoJGyEiYiIQlIhx4SX90r34uYZwWPAb242p8hnbrIvUeIFSkRElCgeCRMREYWEjTAREVFIKmR3dFEeWNfJi38+NseLdUXwDfmJiIjiwSNhIiKikLARJiIiCgkbYSIiopBUyDHhVreaJ/CccOt+ReRcmfrKEBFRhcUjYSIiopCwESYiIgqJKB9OT0REFAoeCRMREYWEjTAREVFI2AgTERGFhI0wERFRSMp8IywiI0Rkp4gsijF/OxHZIiL5InJJQJ7eIlLg5jsuqRVOMhG52K2nikibsOsTDxEZIiJ57nJUi/E9f7nr/Y0i8qiIbBWR+5NX25InIt+JyA4RGR92XeLBbXTPy1OWVPTtVUSy3GXPE5H7Ei2vVDXCItLW3dkErqgAD6tqTpTy6ojIGv/OS1Xnq2o2gHF7KHO5qmar6mi3LBGRO0RksYhsEpF3RKSGb15NRORjEflHRJaKyOVFLKd/B1L4N9CX/riIrBeRn0Wkie/1fiLyhL8sVX3ZXZ5QicjVIjJFRHJFZEQcRYx0P++tbnl9ROR7EdkYbeetqq0BDI2h3G6qeoevnsNEZJ77+Q+Kshw3iMhKd77DRSTLl5bj1mmbiMwVkaOCZupuqMPd78pKEbnRl9ZMRCa635VHIt43WkR6RCzrEQACv08lqYxvo3VEZKSIrHX/3vSnR6lbVRF51s27UUR+9KWdLyIrRGShiPT2vd5aRCaIiPfQ8mIsT4kRkY7i/LjbKCJ/ishpxSwicnutJSKvishq92+IP3M826uIHBqxjyw82DjDTX8+Ii1XRDYXsczpInKfiCwXkc0i8quI1HLTjnTX5QoROcf3nloiMk1EqvuWJdddn2/G/nEFK1WNMIBnAPySxPIeAjAnSWUNANAfQC8AewGoAuApX/obABYCaAjgRABDRaRPEeUV7kAK/14FABHpCaA7gEYAxgO4zX29JoCbAPwnScuTbMsB3AdgeJLK2+qWdXOSyis0A8CVAKZFJojIsQBuBXAkgBwArQDc7cvyNoBfAdQFcAeA90WkfsB8hgBoC6AFgD4AbhFzxHYbgFcBtATQt7DRdTf+Bao6Jf7FS7myvI3eB6A2nPXaGs62OqSI8oYBqAOgo/v/BgAQkQwADwLYD8A1AJ72vedJADeqan7CS5Mibv0/BvAZnOW6DMAbItIugWIfA1AVznbTE0B/EbkwkXqq6jj/PhLASQC2ABjtpl8ekf42gPeKKPJuAAcDOAhADTjflR1u2uMATgZwHIDnfD+iHgDwoKoGNu6JKjWNsIicC2ADgDFJKu8gAF0AvJKM8uCsoJdVdYmqboGz8zjH/bWcDaA3gPtVNU9VZwB4H8BFccynJYDxqpoL57No5b5+P4D/qurGRBckFVT1A1X9CMC6JJU3WVVfB7AgGeX5yn1GVcfAbHx+A+Gs41mquh7AvQAGAU6XIpyd7l2qul1VRwH4DcAZAbMaAOBeVV2vqnMAvFhYFpx1/J27Ln8B0Mo9IrsVwO1JWMyUKMvbqJveEsBHqrrJ/ew/BNA5oG7tAZwC4DJVXaOq+ao61U2uC2CZqq4A8C3cbVREznRfn5ik5UmVDnB+pDzmLtd3AH6C0yjF62Q4vR3bVHURgJcR3/6vKAMBvF949O0nTrf4GXB+3O5GRGoDuB7Apar6tzp+V9XC/UA1d3oGgJ0A6roHRC1V9d0kL4elVDTC7g7oHgD/jpLWXEQ2iEjzYpSXDucX+9UAknU3EnH//NNZcI52xPeaP71LEeU1EJFVbhfIY2LGVmYBOFREqsA5IpvlHim1V9W3krEgYXDX4SFh12MPOsM5Ui40A0BDEanrpi2I+EU8A1F24u4Gv1eUsgrz/g7gaLcrrAeA2XAa/MdVdUOSliWpysE2Cnd+J4lIbXcdnQHgy4CyDgDwN4C73e7o3wq7QQGsgbOTbgrgaDjbaDaAwXB7rko5CXjN21/Fub0WZ/9XvIKdH1JnIqCRhbMu1wD4MSC9K4BdAM4UZ3hovohc5UtfLSLdRKQbgAIA6+EcHV+blAUoQqlohOHsgF5W1SWRCaq6WFVrqeriYpR3LYBJvl+uyfAlgEvEGResCeD/3NerujvmnwDcKSKVRWQ/OF+KqgFlzQWwD4DGAI6A0/38KACo6u8ARgGYCKA5nF/zTwC4VkSuFZEf3bGsWklctpRz12FpP7EoG4C/p6Ewrh4lrTC9OnaX7UuPlvcBAIcC+AFOw5AJYG8An4rIW+46vjrehUiRMr2Nuv+nAagEp7dmHYB8AM8GlNUUTiOyEc4PqqsBvCoiHVW1AMAVcHq7bgJwKZwfKE8B6CrOeQNfiUjSGqEkmwtgNYCbRSRTRI4BcDh8+6s4ttfRAG4VkerinCB6EYL3f/E4A8BaONtMNAMBvKbBt4BsCqAmgHZwekTOBDBERI520y+Hs58dBqdH4Ao4PT6V3XX5vYgcnpQliRB6Iywi+wA4Cs6YQjLK2wvOBn7HnvL63uMf3A/6NT8czpjDWDhHq9+7ry91//eDs3KXAHgOzqD9UkShqitVdbaqFqjqQgC3wPlSFKY/pqrdVPUcAOfAOaEjDc7YzZFwxtBujXX5KgIR+dK3DvvFWcwWOGNFhQrjzVHSCtOjjRVtiXi/lVdV/1HVc1S1G5wN/yk4Y4u3wjlKPgrA5SLSKc7lSKpytI2+B2A+nB9DNQD8Bedcjmi2A8gDcJ+q7lTVH9zyjgEAVR2jqgeq6uFwjpx6ABgB4HU4ww73Angp1uUrSaqaB6AvnHNXVsLp3XgXAfurGF0L5zP7A85489tFlRfH9hrYyIpIMzg/Il4r4v3b3f/3uMNJMwG8A+AEAFDV6araW1UPgNMzdRGcE8legjOWfCGA10UkWi9CQkrDowx7wxnMX+wuXzaAdBHppKpFPWcwSE84R5iz3fKqAKgiIisBNIl2wkTk2cUi0ipKngIAd7l/cH89LnP/oKp/wzlxoLCMtwBMjrHOiihdRCLSEMC/ABwIZ8xlpqrmicgvAK6LsewKQVWPT0IxswB0g7NDghuvUtV1IjILzthtdV+XdDcAuw0RqOp6EVnhpn/jyzsryjwvAzBRVX8Xka5wxul2ishvcI7EZidhuRLVG+VgG4WzDq70ndH7PJyTH6OZGcuCuDvlp+E0QvUApKvq3+6y7B1LGWFwGyHvyE5EJiC4qzeW8v6BcyBSWN5QFLH/K8726jayveHsC6MZAGCCqhZ1/kjh+oxl6OMxAINVdbu7TU5xt8lMAPXh9CIkTehHwnAO/1vD6Z7dB8DzAD4HcGyc5X0JZ4dRWN5/4JzRuk8iZyyKc3lDa3F0gtN9fI+74Ree8l9dRCqJyAVwfjE/GlBWb3ccTdwv2INwfj1GehTOiUDb4Jx5vb+Yk8CSesJSokQkQ0QqA0iHs4OuLM5ZmPGWl+aWl+lMSmURqZSEelZyyxUAmW65hdvBawAuFpFO7pjhYDhHN1DV+QCmA7jLfc9pcHayowJm9RqAweKMP3aA02U5IqIuDQBcBXOG7kIAfdx13AOlZx2Xi20Uzklwl4hIFXHOubgM9ri9348AFgO4zf1u94Kz3X0Vke8SAL+q6nQ4XdxV3Hn3QelZf7sRkb3d73FVEbkJzo+iEQmU11pE6opzGdDxcD7bhK+hdfWH08j+FZA+AHuou/vecQDuEOfywY5wehk/8+dzu6crq2rh6wsBHCEineGcX5CUE0/9Qm+E3bPpVhb+wenK26GqawDvpI+iuqAiy8uNKG8jgDw3TkQ9AF/AuXTmSwDDVXWYL/1YOBvdejjjC8cVLoO7HFtE5FB3cj8AP7tlTYDTBWmdACDO5U21VPVDd7kmw9nxLYGzgT+Y4PIk22A4XT63ArjAjQcXJkYsfywOc8v4As7Y+HYAXyehnl+7ZR0Mp3HZ7s4L6lxv+jCcbse/3b+7fO89F07juB4UUeinAAAgAElEQVTO53+m73vazz1aLnQXnO7Ov+GMY/3XLd/vf3AaicLu6wfgnCOwBMAnWkouVSpH2+hFcBr/pXCOjlvBnLEOEZlV2DXqdtmeCqe7ciOcs9sHqOpcX/56cHqk7nTfswvO2PF3cH6oXJPg8qRSfwAr4BzVHQngaHWuyAAQ1/baHc7VApvhfI/7qWq0np94DEDwWc8HwRnv3e3SJLfL23+1wXlwLhlcB2dfeqc6V0oU5s8C8F/YvYzXwFmX38LpRUn+pWeqWqb/4GwcWwD8FWP+tnAus9gGYFBAnsIGYAOAY8Nexj0sz4VuPXcAaBV2feJchsFwdpwb4FwqEMt75rnrfXgReXbA2YHeG/YyJvj5fANn5zYm7LrEWf+Kvo3ucXnK0l9F317hHBFvcD+DuxItj88TJiIiCkno3dFEREQVFRthIiKikJToJUpHp53Fvu+QfFPwXtKvb+P6DE8q1ifAdRombqPlS6zrk0fCREREIWEjTEREFBI2wkRERCFhI0xERBQSNsJEREQhYSNMREQUEjbCREREIWEjTEREFBI2wkRERCFhI0xERBQSNsJEREQhYSNMREQUEjbCREREIWEjTEREFBI2wkRERCFhI0xERBSSjLArEIb8Pvt58dXD3rXSnmvbJmXz3XzOgdZ0relrTZ3m/Zmy+VLxbBhwkDU96cHnvLjTM1d6cfOHJlv5dNeu1FasnMto0cyLG4zc4MU/TO1k5evwrEnLnzUv9RVzpdevb02vO97sK2qPnObFmptbYnWiso9HwkRERCFhI0xERBSSCtkd/fexWV5cJ31Lic135Yk7rem8/uY3UJ2TSqwaFEVGk728+N7/vBSYb/ZVz3rx8U8eaqXp5s3Jr1g5ltGooTV9z9hRXtw+s8CLj1jXyMqXP+uP1FbMx98F3W/8NCvtwMofevFVv/3LJPw6K+X1KsvS69W1puc91tyLe7c163bZ4XlWvvLazc8jYSIiopCwESYiIgoJG2EiIqKQVJgxYcms5MVHHDE9lDpU/7WyNX32xT948fe1mlpp+Rs2lkidyLH62BZefEzVvMB8+005x4vrb5mf0jqVRxlNm3hxzZHbrLS9K6V7cftvL/fitgPtsdiSNOe+HC8+O3u0lbbf47d48V6/TiipKpVJq68+2Ivvuu41K+3Eql9HfU/feidb07uWLU9+xUoBHgkTERGFhI0wERFRSCpMd/Tm08xdsp5s8pQXd/zoaitfW0xKWR1ya6s1fW3tuV48tnpHOzO7o1MqrWpVa/rYa8fH9L6sd2qbCdXgjBTV+l7mrlgf5TwTmK/j4NVeXJL3IdODulnTf570ghcf/ttZVlqz4Wb7zU9ttcqk9Hatvfilfz/uxftUspudAkS34rnq1nTjf5lL1XatWJl4BUsJHgkTERGFhI0wERFRSNgIExERhaTcjglrr32s6WceesKL39hkLkfpMNi+zCSVYzsHHfN7Ckun4sg92B6Dv6/By4F5txWY243WeGtiyupUHvmfjAQAa07dEZi3x/+u8eJGS0rukh//OPDgN18NzLflc/v2mdXWLUhZncqDObea8yf8l5/FalL3t6zp+T+b7fD012+00lrd/6sXF+wI/o6VRjwSJiIiCgkbYSIiopCU2+7o9bfZd+NpmmEudLjxmhO9OHP91JTWI6Ox6cJ6pbl9x5085W+gsCw8PfbusTP/6OubKp937UmVJU9kW9N/9BzhxYNX20NGTV4xTx8qyUt+lvWu5sW9suwLZrpMGOjFzZ/iXbGKkt6pnTX97ZGP+6aqeNFD6+yhoCkbzFOURra295F+7Xx3PXyx33NW2kPDT/XigoV/x1Tf0oKtABERUUjYCBMREYWkXHVHr7v0IC9+r+t/rbTXNu7txZnfprYL2m/2Pebs0Dy1O9kGLjrKi/NXrymxOhFw4v4zAtM2Fmy3pvOGmIfPp7E7ulhUxZr2bwOT1uVYaenbVyNV0qrbd1+ad38nL/7olEe9uACZVr7mZ/2WsjqVN2t71rWmczLMXekuW3KYFy89cIuVL62aGTrsfrk5Q/6mS9+18vWrbr4fh9nPwsGnoxZ78ewTy9adtXgkTEREFBI2wkRERCFhI0xERBSScjUmnNZ3rRfvlZFlpb381nFe3BSpvdQgvXN7L37jSPMUlly1Hxa/+FFzSn+13NQ9vYkcuSfs78VPN3kxMN/SiMf2pP3wa/SMlJAvOnxkTV88to8XL97c2It3vmzfqSpWKw81T7k64YDpVtonez3rmzLjwL2mn2vlq40/4pp3RZRv73JRAPP5z3yhqxfXwc92vq1bvbjxI2bf/O7J+1v5zqv+mZlQ+1KyVblmzF935MZe6VKAR8JEREQhYSNMREQUkjLdHZ1ev741Pbjd54F5mw4tubvdzL2ylhf3yDKXZDyzvpOVr9oodkGXpFX7Z+45E4CTP7vemm4Lrqd4NXiqijX9/TBzbUmfKvaN9l9u/r0Xp8Fc2lTwqCIeVhkILuPtzeYStLq3x/bAedpd9TNWBKZtPNZ0Odd5Jbby/tPik4hXgo8Zx/3awYvbrZ8c2wxKCR4JExERhYSNMBERUUjKdHe0VLVvm3Js1Y1e3POXAVZaI8wpkToBQL2cf6K+/ubCHnY+zI+aj1Kj0r7rA9Pm7DR37enw5ForrSQfJlDeZHxn353uiUOO8OJ7D86x0pYeY7qM/zz5eS+enGvfdeuCry+Pad5tXzNnyX7+3vDAfA/PPtaLm8yYFZiPirZ5VGP7hc4mHNTJDOn8uH9PK9uafc1DPvQks+/skml3K8/JM1eXdPY9zAEAPjz+KS/+vwMvNQkTZ+654iHjkTAREVFI2AgTERGFhI0wERFRSMr0mHDBPxus6XvX7OfF57eeYqX92Li1Fyf7yRoZLZpZ0z/t845vyvzO2T6xXsQ7OSacajtOMuNPU/b3Pwg83co3L6+BF+fP/yvV1aqwdq1c5cVVP1hlpbX7wMQnXL4fgrRDbJegpO1tLlvxX64EAPet7eLFLa4z55JE3CyNiqHRJwut6fm37fTim+vO9uL/+8g+Pyfo8rFz/jrRmt5+rbkk9bS3x1ppF9ZY4sV/XWv2ua0n7qHSpQCPhImIiELCRpiIiCgkZbs7evNma/rrZab7adw+b1lpKz6radJeOKjY89rQye4yyc4xXVgH7rXIrlfAfXYkvhv/UAK21zPdzpmSHpjvlqmne3FLlP7LGmjPFt9l1ndkl+fX95uHzGcvKQN9lmVA5DDfZTebO8+98r9HvbhdZjX7jb6HMbT52lxe1OHquVa2gq2mS/vB70620i7ua4aaHuphxjVe6mZ3aRfMKLlLVWPFI2EiIqKQsBEmIiIKCRthIiKikJTpMeFIte82t7E8fMh5VtqHXUZ48UN32Q+VjsWUXHs8Md/3+6VHpZ0RuQXRNH/qN2uaT2hJvdy+G6K+7r9NJQA0fSm2JyxR6bX2Mvtcj5kHPuPFi3Ztt9KqrIncZinZst8zt6q8EDd68T9n29vejo1ZXtzxZnN5YP7WrQjS/tbZ1vSRbc05Hd90HuXFd91lH2c2OR2lDo+EiYiIQsJGmIiIKCTlqjsak013b80T7KT+va/14g1ts1BcdV8M7sJe9kFna3rqASOi5ou8pIqSL71da2t6yv5v+FO96MstXax8md/aT/uhsmfb0VsC086cfok13eD7aamuDvn4u6az3wvOF+sTyyL3pZs+9G3Pvt3xQ3uPsvI927i3Fyf7zonx4pEwERFRSNgIExERhaR8dUcXIX2s6X6qOza5ZW9fVN1+4YDo+bTXPta0/DQ9uRUhrOrTwJoOukvW098fbU23xaSo+ajseKH769b0inxzFm7dx6uWdHWoBNV/wTzU44Djz/fiSd3tOyded1OOF7f+N7ujiYiIKjQ2wkRERCFhI0xERBSSCjMmnFIRN8hKC/htwzHg1NtRJ/rdygBgaq65S1LHh5ZaaXyYe9m09LaDvbhXln3Z0cRcMw6czkuSyrcCc3FT3UfMel/7un2ntDnnmruonfzWACtNp85KUeWKxiNhIiKikLARJiIiCgm7o5PBfl44CvhohtA0OGJZYNonm/b14vw1a0uiOpRi/c4b48UFERvixVMGeXEL2A9PSa9bx0w0qOuF+XP+SG4FqcSl/fCrF/d+9WYrbfZFpjt68/12V3WNs8ylpiV5d0MeCRMREYWEjTAREVFI2AgTERGFhGPCSVBQOXgMeE1+bgnWpGKSLPNUrFP3mhGYb93ObC/WXK6X8q4g3xxjrL76YCvtxEvGefFHCxp7cWl86DvFr82wJdb062c18uIfu75vpR3X7SIvThtfcpeT8kiYiIgoJGyEiYiIQsLu6CR447jnrek5O0339HkjbvHi5phQYnWqUPLN3XKGzTnESrr+4EVePHZJGy9ugnDujkMlZ85hr3hxwWH25UudfzRdj22GbPXiWB8qT2XDriX2nfHePe1wL+7/7Ugrbe3NO7y4wfjU1suPR8JEREQhYSNMREQUEnZHJ8E9C0+xprc+28SLm49iF3Sq6S7z+IWcW7daaR0f6O/FMr06qHz56g7TvTj7tsZW2s+TOnhxhyeWW2mtV87z4vwdO0AVg/+OaOcsOMZK+3Tfl7z44gOvNAkTZ6a0TjwSJiIiCgkbYSIiopCwESYiIgoJx4ST4Uj7NPhqWBqQkVIt/8+F1nTzs0KqCJWIyp9O9uI1n9ppbTDRi3eByLbtNPuytUkT9vLi9e2reXHtiUgpHgkTERGFhI0wERFRSNgdTUREFU7+2nXW9LB2rby4Nn4usXrwSJiIiCgkbISJiIhCwkaYiIgoJGyEiYiIQsJGmIiIKCRshImIiEIiqrrnXERERJR0PBImIiIKCRthIiKikLARJiIiCkmZb4RFZISI7BSRRTHmbyciW0QkX0QuCcjTW0QK3HzHJbXCSSYiR7n1LBCRo8KuTzxEZIiI5LnLUW3P7wBE5C93vb9RRB4Vka0icn/yalvyROQ7EdkhIuPDrkssKvo2WRQRyXKXIU9E7gu7PrHiNlq0RLbRUtEIi8hYdwG2uH/zilnEw6qa4yuvcCewxfeXDgCqOl9VswGM20OZy1U1W1VHu2WKiNwhIotFZJOIvCMiNXzzbCIiH4vIPyKyVEQuL2J5b4+o23Z3B1PPTb9ZRNaKyO8i0sX3vl4i8pG/LFX91l2exbF/XMknIh3dL+JGEflTRE4rZhEj3c97q1teLRF5VURWu39D/JlVtTWAoTGU201V7/DVc5iIzHM/70FRluMGEVnpLsdwEcnypeWIyPcisk1E5hb1o8fd2Q53vysrReRGX1ozEZnoflceiXjfaBHpEbGsRwAI/D6lgojUEZEP3R3k3yJyfjGLiNwmAz+PBLbJxiLyiYgsd3fmOf7MRc3TTT/SXY/b3PXaImjGRa17t5yFIrJCRM7xvV5LRKaJSHXfsua6y/rmHpY1JUTkXBGZ467Xv0Tk0GK83dpG3fL2E5Ef3f3YKhG5rjCN22hsSkUj7LraXcHZqto+CeU97CsvW1XzEyxvAID+AHoB2AtAFQBP+dLfALAQQEMAJwIYKiJ9ohWkqkP9dQPwEICxqrpWRBoDuBhAKwDPA3gQAEQkA8AjAK5PcDmSzq3bxwA+A1AHwGUA3hCRdgkU+xiAqgByAPQE0F9ELkywqgAwA8CVAKZFJojIsQBuBXCkO99WAO72ZXkbwK8A6gK4A8D7IlI/YD5DALQF0AJAHwC3iDmCuw3AqwBaAuhbuEG7O/AFqjol/sVLmmcA7ITzfe4H4DkR6ZxAeUMQ/HnEqwDAaABnFHee4vzg/QDAnXC+s1MAjCxiXkWt+8cBnAzgODifU7r7+gMAHlTVzfEsXLKJyNFw9jUXAqgO4DAACxIorx6cz/8FOJ9LGwBfJ17TirWNlqZGuLQ7GcDLqrpEVbfA+TKfIyJVRSQbQG8A96tqnqrOAPA+gIv2VKiICJzG/VX3peYAflXVTQC+hfMlA5zG9xNVXZTEZUqWDnB+mDymqvmq+h2An+AsV7xOhvNDapu7zC8jhs9zT1T1GVUdA2BHlOSBcNbxLFVdD+BeAIMAp8sUwH4A7lLV7ao6CsBvCG4ABgC4V1XXq+ocAC8WlgVnw/5OVTcC+AVAK3F6VW4FcHuiy5gocbobzwBwp6puUdXxAD5BYuuzqM8jLqq6SlWfhfMZFneepwOYparvqeoOODvkbiLSIbKQGNZ9NVX93d3udwKoKyI9AbRU1XcTWcYkuxvAPao6UVULVHWZqi5LoLwbAXylqm+6R/ib3c85IRVtGy1NjfAD4nTB/iQivQtfFJHmIrJBRJoXs7wr3a6EqSIStBKKQ9w//3QWnF9S4nvNn94Fe3YonKONUe70nwC6ikgtAEcBmCUizQCcC+B/cdc+tSTgNX9X+gYROSSBcmP9PBPRGc6v8EIzADQUkbpu2oKIo5oZ7usWEakN50dJZFmFeX8HcLS7jnsAmA1nZ/K4qm5I0rIkoh2AfFWd73vNq39xt8kYPo+ki2Ge1rp2u1j/CqjTntb9ahHpJiLd4Bydr4dzdHxtEhYlKdyj8x4A6oszXLRURJ4WkSq+PMXdRg8E8I+ITBBnyOjTOPbTxVXuttHS0gj/H5wjviYAhgH4VERaA4CqLlbVWqpanDHPJ+E0jg3gdDeNEJFeCdbxSwCXuGMONd06A0BVd6X/BOBOEaksIvvB+fVVNYZyBwJ43z26hqquA3A/gO/gdGvfBOAJd36nicgP4ow9N01weZJpLoDVAG4WkUwROQbA4fAtv7sOi3PSwmgAt4pIdRFpA+coOJbPMxHZADb6pgvj6lHSCtOrY3fZEe+PzPsAnB9fP8Dp9s0EsDec7/1b7hjb1fEuRBIUuaxxbJN7+jxSYU/zLO76LCrv5XC20WFweguuADAGQGUR+codozw8noVIooZwvmdnwvnu7QNgXwCDCzPEsY02hbP/ug5OD95CON3BqVTuttFS0Qir6iS3KyNXVV+F06CdkEB501R1naruUtUv4JwEcXpQfrFPkgr6JTcczhdsLIBZAL53X1/q/u8HpwtjCYDn3HkuRRHcX6FnwXRFF9b/bVXdT1WPh3P0lwtnnON/cLpp30MpOipW1TwAfeH8aFgJ4N8A3sUeln8PrgWwHcAfcMab3y6qPBH50rcO+8U5zy0AavimC+PNUdIK06ON922JeL+VV1X/UdVzVLUbnJ33UwCugdPV9TucHpDLRaRTnMuRqOIsa6zlFZYRU3kxbpOJzLO46zMwr6pOV9XeqnoAnCOmi+CckPQSnC7gCwG87g49hWW7+/8pVV2hqmsBPIoE9rNumR+q6i9ul/7dAA52D1J2w200ulLRCEehiN7FmZLyIk7givrr3h1DuUtVc1S1KZyGeJn7B1X9W1VPUtX67sZYF8DkPdTrdAD/wGnYd+M20kPhNGptASxxx4p/gfOrrNRQ1Zmqeriq1lXVY+H0bOxp+Ysq7x9V7aeqjVS1M5zvamB5qnq8bx3Ge+bpLADdfNPdAKxyeydmwRkXqh6RPitKXdYDWBGlrN3ywjmJbaKq/g6gK4ApqroTzlhWqrvfg8wHkCEibX2vBdV/j4r5eRS+Z4/bZILztNa1Ow7eOqBOMa97OCcUDlbV7TDrcxGcI6mgE4RSzv08lsLZFybLzIjyCuOo+1puo9GF3giLcxr/sW43bob7C+kwAF8lUOaZIpItImlu1+gFcE4sSaSedUSktTg6wfkVeY+qFrjpHd2u00oicgGAY9w8RRkI4DXVwBt4DwYwQlWXw7kEqb2INIRzJl/cZzWmgojs7a7DqiJyE4DGAEYkUF5rEakrIukicjycDSHh6yrd9VMZzo4i061z4XbwGoCLRaSTO2Y0GO4yuOOj0wHc5b7nNDg/hEbtNhNT1mARqS3OyT6XIuLzEJEGAK6Cc1IQ4HTn9RHnRL8eCGkdu+OjHwC4R0SquUM5pwJ4PYFi9/h5xMNdl4WXqGS507HM80MAXUTkDPc9/wEwU1XnRs4j1nUvztnHlVX1M/elhQCOEOes8iwA6xJd3gS9AuAaEWngfr+vh3NFQyLlnSYi+4hIJpyhv/GJjplWuG1UVUP9g/Pr8Bc43QAbAEwEcLQvvTmcroPmAe8fAeC+iNfGwenf3wRnsP3cKO8bC+CSgDJ7A1ga8Vo7APMAbAPwN4AbI9KvB7AGwFYA4wH0iEjfAuBQ33QTALsAtAmoQ3v3c8nwvXYzgLVwury6RuRfBOCoENfjf+GckLIFzvh5m4h0a/kj0oYAeCPitbMBLHc/7+kAjo3lfRHpGqUeY93X/X+9fek3AljlfndeAZDlS8tx37/d/S4c5UvrB+ds28LpLDhDGJvc8m6MUr/XAJzlm24GYJL7OT4SkXcQnB1cSa3POgA+cr/PiwGc70uLZ5uM5fMYi2Jsk751bP3FOk84XYpz3fU5FkCOL+15AM/Hsu5985oOoIXvtSPhbJcrELEPivYZlcA6zQTwLJz97Eo4585U9qUXaxt1X78CTm/gegCfAmgWy/si1l+F3kZL7AuQwi/Wi+6X568Y87d1v4TbAAwKyHOYuxI3IMrOvzT9uRv6Bre+fcKuT5zLMBjOzn4DnMs9YnnPPHe9Dy8izw44P8buDXsZE/x8voHzI3VM2HWJsb4Vepvcw7JmucuwFc6lNKHXKcZ6cxstelnj3kb5KEMiIqKQhD4mTEREVFGxESYiIgoJG2EiIqKQZJTkzI5OO4sD0CH5puC9pN8ogOszPKlYnwDXaZi4jZYvsa5PHgkTERGFhI0wERFRSNgIExERhYSNMBERUUjYCBMREYWEjTAREVFI2AgTERGFhI0wERFRSEr0Zh1ERFTxpFWt6sXdJ2y20u6qP92Lj5l9uhdXOvrv1FesFOCRMBERUUjYCBMREYWEjTAREVFIOCacAhmNGnrxzrZ7xfSezPnLrOl5t7Xy4lqzzX3A68zZYeVLG/drPFUkKjN2nNzTmq7y5TQv1h6dvHjhKdWsfIce8ZsXj/uua2D5jX/O9+LKn06Ou55k848Dzx/W3os/qj/Mylfgi5fMaOzFrcExYSIiIkohNsJEREQhYXd0nDZecKAXrzvB7iK+dd/RXjygxhcxlffyxubW9OnVP/Ti2mdVDnzfSU26x1Q+UWmXXq+uF+ePrOLF77R91Mq3Kj/Ti2umjfXi5hlVEWjgj4FJqy/Y5sXLn6xkpf1r6HVeXPfFn4PLp90suKObF8/u86QX91twvJVv3f0tvbj16Impr1gpwyNhIiKikLARJiIiCgm7oyOkdevoxXOvMWdbjjvmcStf/fRfzHuS8Fvm4pqLI14J7oImKo/mP2GGZOZ1eNmXYnczN0g38bMb2nnxtM32kM7SrbUC55Uu5pzcz9t/GrVsABg5+L9efPmcq620tPHTQcF2NtgV9fWZ49pa0y1HV+xufh4JExERhYSNMBERUUjYCBMREYWEY8IRtras7sXzj3/Ol1Jl98wJen6DuSvWm3/vH1cZNfFnsqpT7qXtY+6utKORfXelRX3NXcnO7PmLlZanZqDw+9fN3Zsa/7DRyqe/zkpKPSsKPaibNT3y4Bd8U2bXNHq7PSb84M0Dvbj6rLUmYc0/Vr609UuC551m1mm7R6704tlnP2Xla52Z7cXbB2+y0moOMnfG27VyVeC8KqrM7J1evLnAxM2/yQ2jOqUWj4SJiIhCwkaYiIgoJOW2OzqjaRNres7/NfXihhNM12ONt+07tKTlqhfPzzNdKEt22Zc7NMvY4MWDfh9opa2fY+780/AXU16tCXb3mG7Z4sU1N7BbORm01z7W9IKrTPzWQS96cfdKEdeixOpmc4P/7TfttJKGbTDd3c/OONxKa3vxHC8u2GHfYa2iyqtp351qn0pmd1QAs93c/MpFVr5mH07w4nzEqcC8s80NZh/QsZJ9GdLMU5/w4h+6vm+l9TrKdGPXfIPd0eltWlrTsw4b7sXXLT/S5Pt+GsjgkTAREVFI2AgTERGFhI0wERFRSMrVmHB6rZpe3PPzhVbaR/U+8eJeU+xxH7+sL83lKTefOMiL82fNs+fV0dx6rc68v6y0OgXzo5Yd/SZuFI+CQ8zY7yIzNIfPez1j5Wud4b+0zIwDf7PdvuTs9tl9vXjDYnv8//e+5rKVO1eZp2c93GiKla9bFfMQ8kd7jrTSbrthkBc3fWACCMivLIFpe08Y5MXN7y+5z6vtVZOs6c+OMg+ZPyt7nZW24ZStXlzzjdTWqyyYNyT4NqElKfd4c7nn5mbBTVz9qfYlZzo1nEsMeSRMREQUEjbCREREISnT3dFple0nDeW+b7qjb6/3nZXW/gPTZ9nhQ9PtUNQlDpFd0FbanD9irCUlw4K37EuP3gy83MjuZj5v4dFe/MtccwlFh+vmWPnqbzXrun7EvC/vfpQXr762hRff8Jx9mdPghmO9eNz2xlba9KtNl3bfN0714l1LlqKian9bcPdf+tTqgWkl6Y5fzDDFWX1ettKu6vyjF3+G2iVWp9LqsQNGBqb99NZ+XtwIiQ8v/PXmvtb0Ewe87cVdK4334obpWYFl/JlnDxCe+v4NXtz6pomR2VOGR8JEREQhYSNMREQUkjLXHZ1e23T7zL23nZU2r+OzXjw14h7hHe5Z4MX5m+yz4qh0SKtmP1Thj3u6evGcw+2zntN8Zzr/4rvLWb+Pr7Lytb/bdDu322DOZi5A7LpWX+bF32SYLu0p/+1u5av7qDmztm+1DbAFnwlckaTt3cGLe9f6xkqbn2fuJFZvZl6J1akotX/wDXn1Ca8epVV6jRpeXC3N3ul+vd1sz40ei60LWjLNXdR29tnbSrvjuVe8+LDKU620TDH7g8m5pgt6wNyzrHw3tvzai0+pts1Ke7avGW54fPhpXpw/O/rVLsnCI2EiIqKQsBEmIiIKCRthIiKikJS5MeHlF3T04jIwzA8AACAASURBVHmn2Q/g/mSrGS9++aSjrbT8NfZdraj02XBKV2v6u7P+58VpsB/sPma7Gfd58ErzFKs2X9uXFsT6lB3JMJtCWvvWVtpLH9Xx4v++9qoXd620OqIUU8d0sX/fdp10vhc3WV1xv4t/DDR3VTo3e42VdsjM/l5c44tfQKXfwuu7ePEhlcdYaZ2+H+DFbfBrYBn+py/Nu6qhF88++6lo2QEAY7ZnW9NXfjXIizs8sdaLs+bb29ozMOcRPTWmmZX2WYcPvPiB5uZy10qzA6uRFDwSJiIiCgkbYSIiopCUue7ozQdsD0x7YqF5cHSV+RW3y6+sUvsGVNihwZf1bC4wd8ZaeYC5rGH76T2tfG3aroj6/o077LutndXCPGj8qlqvW2lTdprye2X5L26yu8j9ftphXwTV5D6zLJqbG5m9wrjh+M+92H9JEgBUeqaub4rbb1kgewdf7pn5V5XAND//gx/m9jGXIkZeRthvwfFevOmWJlZa25/N5YGxDkH9uaCR/UKH6PlSjUfCREREIWEjTEREFJIy1x39dq9hvin7N8T7ncxDPQ969N9WWstPdnpx+thpoNKn9sf2Df0vG9DPi9/oYD+w9ZRq5i5ZZ1xh7pSWr8H3wspVc8P2LCnqq2+n2V3Qxq6Ijq/eM8/14jpX2Wm6IJxnlZZmL6w7zJqu/NnkkGpC8erQYFWx3yPdO1vTHx7ynG8q04s6j73Mytf2YnP3O9kxo9jz3ZP/rDbPIa489jcvLs7d9eLBI2EiIqKQsBEmIiIKCRthIiKikJS5MeGeWWbMIE/tcbfaaeayk7nn2E/dyTvb5O0y5nIvrvmLfanKlqZmrLGGefAS6s3cGlintXvbT/9pONbcSSmfl0rFrGDzZms66xgzfVnD0620OUNyvPiY7mb8Zv7GBla+v5fV8+L0SuY7cEr7mVa+hxtNQXF1+t4es2r/b/O0pV2rIu+mVTGl16ppTVdPWxpSTSgVmlY1TwtLizymE0U086/NsqY7Zpp9evdfLvDi1v3su2wle2w2M3unNb11l6lXwY4dkdlThkfCREREIWEjTEREFJIy1x3d8tNLvXj+Sc/H/D7/Q5/nHfWiSTgqKdWyTL7V3B3p+tm+y1ZOSu3Docuz/Iju3XZXmOlFvtcr4W8rX9uI6UJff9jJmi6qO3rRLvPw775P3WLKfty+pCZ/1y6QbenF9uUo/ap/78XTtuaUcG2KL/eEjYFp2woqBaZVFAVqjuMKIjuMA+5417jhBmva/75O9c0lT+uTUL9I/odFzDpsuJV22MyzvbhGCd6xjUfCREREIWEjTEREFBI2wkRERCEpc2PC7a8yp60f+559iciApz/14qpp9pNqTqpqHiDuHx9OhZ5Z5tT88fu+6cWd/3utla/1zT+ntB5kWzj0IC+etv9jEanB43tnPmzGgfd6ZoIXR78Ag8qyXUd0t6bf2fdp35R9ac2HD5mnttXExFRWq1ypdbF9+c+kceYSpaebm334QQ/dZOVr96Q5v2PXsuVxzbvjSFPGqnz7iXyVn6jjm+KYMBERUbnHRpiIiCgkZa47Wn2XgWR+O9VKe7vDXoHve/JMc6lQfqY5df7gm+zLTB5s9EuiVbT47yLTtFv0B8xT6iy/+WAv/qrfw15cRaoGvueJ9W2s6UavTPfiVD9RhUqevwv6n+vsO+N1yDRd0Fcu62Wl1RppnsZWUYYm/Jf4AMBhNb8rdhmRXckPHdXXi7uNMrcp/P2CJ618Vx7ex4tXnFjHSstf948Xb+hvhp0OuX6Sle8/DX/y4u7v2N3drUeHM6TAI2EiIqKQsBEmIiIKSZnrjo5XtfcnRX39024HWdMP9jfd0dvU3OC7+49XWPlavGTOsF577TYrbcr+9gPoqeTkHdPDmv7oatMF3TwjuAt6se+uWJ/835FWWta25A5RVCQ1FtkPWfHffSxMkmF2fRtuMA8KmbLfO1a+b7ZX8eL5d9p3/6qUV/yHfpR1+X8utKbfWdnTi09rPdpKa3HIYi9Or1HDlLFpk5Vv14JFXjx1X3NceFh/+2qSOjPNnbakXp6VtvDpZl486zBzRnvkGdD+LujWN5WOM9p5JExERBQSNsJEREQhYSNMREQUkgozJhyk+Vf2nbXQ34RVxdxFac7hL9vZWhztxV/kfBVRavTfNotX2qfVt7We/0PJsOgk+25oOQHjwCvy7bHJAdf/24urfh79/AEqvmqj7M9y9L0dvbh15TVW2h9Nu3jxrqXLEp53wSH7ePHCK+20Mzqay86GNrDHgf2G3jTQi6t8NTkwX0W14xIz1vvoqA5W2mcdPvbi68aYy7smP2+fh5O9PPrTx9bsb18QuP+15vKlR/Yab6X5LwUdtjHHi0f87yQrX+vhpe8uhTwSJiIiCgkbYSIiopBU+O7ozCl/WNMHTjvPiyfu93bg+17P+cY3Zf+WyVVz+vxJs82dujpca98U3L54g+KVXtd08/96+uMRqVmIpvf4q63p1h+yC7qkXVnLvtxl1Wema3PKP80TLv/BlsO8eJ9Kwbu6qTvNlth/8sVWWuvv5noxt9fd5c83+7QfT7Uv4ar9ubn72GN7jTMJ94xDEH+3ckEx7k/XZfyFXtzmxrVeXGdZ6et+jsQjYSIiopCwESYiIgoJG2EiIqKQVPgx4YLNm63pRtfU9uKTh5/ixbfnfG7lOyjLjBCN2lLPSrvji3O8uM0N5tZoHFNKnvTaZj1dP8mMMWVL9DFgAHhonbk8pu2l9rkAfDpSyfBfMrL6uh+ttLvrzzAT/jhuZve2K2Lrm2HuSIsLRprbI7a81R5D5DYbO//tJwHgo97mkrMnLzRPStra0r7l5FfHmfM4jv3qepNQxKOp2r+0w5rO+WWmqUcslS1FeCRMREQUEjbCREREIanw3dGRdi0yT/7AESa89lr7ljub9zdP5+gweK2V1ubv0vF0jvJs7Snm7jzHVP3ei/OL6ML64u7eXlxtKy9JCkMd3x2LfvmxnZX26Eemi/HG2vZwQTw6/HCRF1f6zb5zWtMHJnhxS5T+y1jKovxVq724yYOrA/NdA3M3rXaI7YllRWzmZQ6PhImIiELCRpiIiCgk7I6OUcMnJ9jTvrisnY1XHpxx07denK/B5za3+fRyL243il3QpUnkA+K/7VLdxNgv4fJbYfqeMxGFjEfCREREIWEjTEREFBI2wkRERCHhmDCVSd2qmEvJ0sX8lpy4w77HUaeHzaURHLsnotKGR8JEREQhYSNMREQUEnZHU5l0/Zvm4etzL33Wiy8afo2Vr9kC+9IyIqLShEfCREREIWEjTEREFBI2wkRERCHhmDCVSS3uMmO9x961jxc3A8eAiajs4JEwERFRSNgIExERhURUy9PjkYmIiMoOHgkTERGFhI0wERFRSNgIExERhYSNMBERUUjKXCMsIkNEJE9EtohItRjf85eI7BSRN4rIoyKyVUTuT15tS56IfCciO0RkfNh1iZWIjHDXz6IY87dz13++iFwSkKe3iBS4+Y5LaoVLkIhkucuQJyL3hV2fWHAbLVpZ3Eb9Kvr2GsvyFEcojbCIdHS/iBtF5E8ROa2YRYxU1WxV3eqWV0tEXhWR1e7fEH9mVW0NYGgM5XZT1Tt89RwmIvPcL8egKMtxg4isdJdjuIhk+dJyROR7EdkmInNF5Kigmbo72uEisskt70ZfWjMRmSgi/4jIIxHvGy0iPSKW9QgAl8ewrEklInVE5EN3J/m3iJxfzCIeVtUcX3mBn4mqzlfVbADj9lDmcvd7Mtots7GIfCIiy90deo4/c1HzdNOPdNflNnfdtgiacVHr3y1noYisEJFzfK/XEpFpIlLdt6y57rK+uYdlTSoRuVpEpohIroiMiKOIyG20j/t5bIy28+Y2WrJEZKz7Q2CL+zevmEVEbq+FDfMW3186kND2KiJyh4gsdj/3d0Skhm+eTUTkY/dzXyoiRX6mInKNu91tcr/bh/jSzne3x4Ui0tv3emsRmVC4LMVcnpiUeCMsIhkAPgbwGYA6AC4D8IaItEug2McAVAWQA6AngP4icmGCVQWAGQCuBDAtMkFEjgVwK4Aj3fm2AnC3L8vbAH4FUBfAHQDeF5H6AfMZAqAtgBYA+gC4RcyvwdsAvAqgJYC+hRu0u/NeoKpT4l+8pHoGwE4ADQH0A/CciHROoLwhCP5M4lUAYDSAM4o7TxGpB+ADAHfC+d5OATCyiHkVtf4fB3AygOPgfE6FG/gDAB5U1c3xLFySLQdwH4DhSSpvq1vWzUkqrxC30fhd7TZ62araPgnlPewrL1tV8xMsbwCA/gB6AdgLQBUAT/nS3wCwEM4+50QAQ0WkT7SCROQAAA8COBNATQAvA/hQRNLdNulBAPsBuAbA0763PgngxiQsS6D/b+++w6Qo0j+Af4u0sICEVUAlLFFyEJCgRMH0E4QTThFUVEQ8Tj1RTk9RELxHfXyMiAlBxTOBuiA+p6iEMwAiSE4qSUAERLLkfX9/VG911zCzzMzOTC2738/z7PO8NVVTUzO9PTVd1dXt4ki4PvQH+oyInBCRWQC+hf6w49UD+h/gTxHZCP0B35zXhorIOBGZCeBwmOwbAUwQkZUishvAGAADAT1cAb1BR4rIIRH5EMByRP7yvwHAGBHZLSKrAYzPqQt6x54lInsBfA+glvdr8H4AD+T1PSaC0kOOVwN4SEQOiMg3AD5G3rZpbp9JXERku4i8CP05xvqafwGwUkSmiMhh6C/lZkqp+qGVRLH9S4vIChFZCv3DJUMpdQGAmiIyOS/vMVFE5CMRmQpgV4LqWyAibwFYn4j6AvVyHy24ekBvv80icgDAEwCuUUqlK6XKAOgM4N8icszblz5A5O/9TOj9d5Hoi2NMAnAmgErQP8K2isg2AF9C/1iDUqqP9/j8pL1DuOmEVYTHGpuEUnuCQwVx1GvVlySNoH+F51gKoLJSKsPLWx9yRLPUe9yilKoA/aMktK6csisAdFdKlQfQCsAq6C+TZ0VkT4LeS17VA3BCRH4MPGbeg1KqurdNq0dTWRSfScJF8ZrW9vaGWddFaNOptv8OpVQzpVQz6KPz3dBHx3cm4K2kRJz7aKpxH83dY0qp35VS34YMwca0vwb8zRsaXqSUivRjJhYKJ3+vp0GPSKjAY8H8SN/7nwIoqpRq44083QxgCYDfAOyE/iFcFUB3ACu9Tn4E9ChHUrnohNcA2AFguFKquFLqEgCdoIeTAQAiUt47morWZwDuV0qVVUrVgf6A00/xnLwqA2BvIJ0Tlw2Tl5NfFicrE/L80LKPAegA4H/QQ77FATQFMF0p9Y5S6iul1N/jfRMJkuv7FZFfvG36Swz15dRxUn1JcqrXjHWb5lZ2CIDnALwKPVpwO4CZAEoqpWZ485Sd4nkTqRLHPuoC99HI7oM+4jsX+v9wulKqNhDX/groYdu60EeWDwF4Qyl1YR7b+CmAQUrP3Zfz2gwA6d6Pp28BPKSUKqmUOh96FCPS9/5+AB8C+AbAEQAjAQwWLRt6H/wAwL0AbgUwGnrou4m3P85QSiXlwC7ld1ESkWNKqV7Qb/A+6Lm1ydAfTLzu9Or7CXr47F0A/SIVVkp9Cr3TAMBtIhLPSS8HAJwRSOfE+8Pk5eSHm+s7EMg/HFpWRP4AcI3X7iIAvoL+Er8f+hf4QAA/KKVmiciqON5HIsTyfqOtL6eOkz6TcJRSBwLJhkl4zVi3acSyIrIEeigNSqmzATwFoB30l/g/oOdjv1JK1ZBCel1Z7qPJJSLfBZJvKqX6AbgC9pxrLPUF5+T/q5R6G3oK59tw5aPcXycCqAZgDnRf9RT0EPUWL78/9I+ezdDTHG/nUtcg6IOzRgB+BnAJgE+UUi1E5FdvSmOm17am0CMawwFsBHCR147XALSNUH/cnJwdLSLLRKSTiGSIyKXQv8gW5KG+P0Skv4hUEZFG0O8rYn0icnng5IF4zzpdCaBZIN0MwHYR2eXl1VKBs1y9/JVh2rIbwLYwdZ1UFvoktvkisgJAEwALReQo9FxWsoffc/MjgGJKqbqBxyK9h1OK8TPJeU7whJBYfsFH+5rW9vbmwWtHaFPU2x/6pMIRInII/jbdCH00FekkoQKP+2jKCcJPFSalvmj2VxHJFpGRIpIpIlWhP++t3h9EZJOIXCkiZ4lIG+i53Ujf+80ATBd9ZnO26DOwtwFoHyyklFLQJ2bdCT1nXFRENkHP9TeN/u1Hz9USpabeEEK6UupeAGcDeCMP9dVWSmV4Z7pdDr0j5HlNpVKqhFKqJPQ/U3GvzTmf2SQAtyilGnpzRiPgvQdvbnQJgJHec3pDb8API7zUJAAjlFIVvBN9bkXI56GUqgRgKPQJQYA+K7CLN3fRCgk+4SUW3vzoRwBGK6VKe8NQVwF4Kw/VnvIziYe3PXOWqaR56WheMwtAY6XU1d5zHgawTETWhL5GtNtfKdUdQEkR+cR7aAOArkqfVZ6GBJ0UFQ+lVDHvfRaFnksr6Z1FGm99Rbz6iuukKqmUKpGAdnIfjZHSS+EuzdmmSqn+ADoCmJGHOvsopcp42/kSAAOgT87MSzsret/tSinVEMDTAEZ7w8c5S13Lev8DA6CPbp+OUN33AP5PKVXLq6879LksK0LKDQKw2But2gWglPfaXZCs7SciKf8D8CT0ySgHoMf964TkHwDQIcJzRwH4T8hjf4UewvsTese6NJrnheRLmHbM8R4P/nUO5A8DsB3APgCvA0gL5GV6zz8EYC2AboG8/tBn6uWk06CHXvZ59Q0L075JAPoG0tUAfOd9jk+FlB0I4JsUb9OKAKZCL0X5BcB1gbzq3jatHuG5bwB4NOSxaD6TOQAGRaizM4AtEbaz9RftawLoBn1OwyHvtTMDeS8DeDma7R94rSUAagQeuxh6+GsbgGtP9RkleXuOCvNZjQrkx7qPdg5T35xTPS/MtuM+mvdtexZ0p7QfwB4A8wF0D+THs79+DT1Pvg/6pLVrwzxvDmLYX6E7ybXQ3+ubQj9z6KmbndDfOd8AaBWSb/5HoX+kjYb+btoPYDWA60PKnwndKZ8R8n/wG/R+2SXa9xPT9nDxT5DHf6AR3oe+B3qpRzTPWettkIm5lDns/RONcf0e8/j5fOH9k8103ZYY2jze2z7roixf19v+fwIYGKFMR+/LdQ/C/Cg7Xf68L/893v/8SNftibLN3Edzf6+n3T4a0v5Cvb9G835i+eP9hImIiBw57a4dTUREVFCwEyYiInIkpeuEuxfpy7FvR77InpLI5QcAuD1dSsb2BLhNXeI+WrBEuz15JExEROQIO2EiIiJH2AkTERE5wk6YiIjIEXbCREREjrATJiIicoSdMBERkSPshImIiBxhJ0xEROQIO2EiIiJH2AkTERE5wk6YiIjIEXbCREREjqT0LkpERIn08zNtTbzumpetvBs2dTTx9nb7UtYmis3xri1NvKG33yXdc/F/rXKDy200cRHYNyjKhn+zqJE7Wph4+sbGVrlzHivqJxYsj6u9icYjYSIiIkfYCRMRETnC4Wgq0IpVqWzivRdmmnhrd/te5xt6vmriY3LCyrtwybUm3rm5gokbPv6bVe74xl/y1FaK3YVtV0XMm1TjKxN36H2blZee9V3S2lRYbb2vvZU+WPeoifu1XBDxeY9U8ve9bGSbuEjIMWIwr8GcwVZepY/TTFz2/fkmPgeR/z/yCx4JExEROcJOmIiIyBEOR9NpT6X5Q1HrHznfynuhz2sm7lTqz4h1HBP/92hw2AsAvm7+jp9oHggzbrbKVe8bVXMpgYJDzrn5taN9Nm2drGS0pnBbeucLVjp4xvL2E4dM/OIue9i63qf+VEHpn0qYuOTv9pRRxoR5Jq6NxXlrbD7CI2EiIiJH2AkTERE5wk6YiIjIEc4JhzjR2Z9TLPbwdhNPP+9jq1xx5V95JbclLRkPFjex2rjVKrerR0MTV5y6wsrL3r8/lmYXar8M96+4s/z65+Kq46ZNF5t4Qo0vonrOkvYTrXRPtI7rtSn56tw9/9SFKE86Lu9jpWc1ed/EwXngRS3sY796WJjchuVzPBImIiJyhJ0wERGRI4VyODq4pGV/z+ZW3sjH/CHG4JIWe9EKcCxw9nxuS1rOf2igiZtVsX/zTMv0T+lvXf4OK6/y2LnhG08AAGnXzMQTbx4b8/Obvn6nla455gcT139mqJW35qpxMddPVNiUv/Wolf5kZoaJe5VfZOIlDa6zyp1Y/VNyG5bP8UiYiIjIEXbCREREjrATJiIicqRQzgkf6dzExLOefSFiudmHypj44UftSxQW/1NCixv7avi/bUoErpT4z3vtJS17s4+buMw2e5kT2YJzwAAgj/5h4pb+FP9Jc/dZByqZeOLAnibO/M6+q4tk+5//eXcvtfIun3q7ice87N/xpVWavc26rfCXlX3ZuGzoW6AkqP3+EBOvu+bliOV+fqatleaSpcQ7vnmLlb4/q7+JVw3wv2ePVrH3jaKrk9uu/I5HwkRERI6wEyYiInKk0AxHB4czH3vplYjl+q27wsT7RlYzcYXZ88IVD6tcnZombj5lnYkblLB/89SfdreJ633Am4znZkfr0lb6+/r+0H7w6mV7s+1lEiMn+1cvy5wX3TaUI0esdPHP/Sv6DJjhD3+u7GFPZQyv6G/r8e/eaOXV7GcPcVNi5DYETY4FblxVJJDY1aikVayiaolopC30lzKd2Lcvb23LR3gkTERE5Ag7YSIiIkcKzXD07gf9m0oHz6a9Ys1frHJF7z3Djxf/gHjsaVnZxCMrTY5YrtrncVVfKBXptstKB69SFrx62U3re1rlMh+KfhohGvVu98+qHntRIytvWMU1Ju7f8Hsrby5KgKggK1atqpV+vNfbJs6Gv5PO/5d9k5UigWPB4H5dJOQYsfPyviY+MsXe9zImJHY/TyUeCRMRETnCTpiIiMgRdsJERESOFNg54Q3vNbXSK1u8buItx/354SIPVrDKyeJlMb9W8K5MAFDnH6v8+gO/c4I3jgeAUlPtqzaRrdi555j4nvO+jOo566fUtdKVsTOhbQqaOK2blR5205oIJYkKpuA88BUz7GV4PUvvNvHIHS1MPH1jY6uczC8ftu6e135jpYfV8r8Deo3eY+Vlj/bnnC+7frCJg8uagPy5tIlHwkRERI6wEyYiInKkwA5H39DQHuoNnvq+6bi/DAnzYx9+Buwh6LXP2jcXmFbdvwl88IYCm548zyqXDl4lKze7L6pu4j5lpkUsN3hzZxOfG7hCGQAchxuNS9kXs19Qq6uJj6/fmOLWECXHgeb+lNHgcvY+2nHZX018xuX+fnkOViEai56wjxGXVu1g4hGDalh5bS9bbuLP3vJvsjJuT22r3Kc3+XVgwXLkBzwSJiIicoSdMBERkSMFdjg60Yo2soeSV99RzsRreowLLW4E70lcdu4GK493EM7dzvPVqQsBWPd4AxOX+i1/nHF+ZWn7Cl9Pt6pi4jIcjk453j84OUpO9/e3K6fbN2I4A+tCi+fJ8S1bTVx91FYr79dRftzivjtMHHqG9Zj3/Ru//OuWIVZesVmLEtDK2PFImIiIyBF2wkRERI6wEyYiInKkwM4Jf7ihuZUenuGfjt4i7aCJOyw7HFV9F6R/ZKW7lPKflx1aOOCepX1MXHX7yqhei7QT6ZHvqBKUX648VlwVNXHwzk5ElDrnPjHXxEvfrmblnT1jr4lHvzbeyrvr30NNnMq7MvFImIiIyBF2wkRERI4U2OHoKgPsU9h7Tu1t4k/q+1d2CQ5Tx6JD4DT47H72cpSvm79j4krj0+Oqn4CmTTeaODvXQf/84Zj4i85Oh/YSFXTBZU0AMOWBS028bZS9bO3FEc+b+MZqd5m4+qi5SCYeCRMRETnCTpiIiMgRdsJERESOFNg54ez9++0HLvbTXXv/zcQ7Wkb+HVJhtb/OpNzb9vzBzreOmHhN8/esvAl7M02cvnKbiV3d0YdSb9Pxo1a61M6jEUoSUaqUmuYvZ1y6KPLypSW3PmfinqNaJ7VNPBImIiJyhJ0wERGRIwV2ODo36VnfmTgzK7461nR9zcShy1HGre1k4nM2R3cDazr9DOr1ecS8q14fbqWrz07uMofC6oZNHU08qcZXEcv9/ExbK827KlHo8qXnl3Yx8ZBO61PWDh4JExEROcJOmIiIyJFCORwdj6KNzgt5xL8BdOiZsJWfL5mCFhV8Bx8+x8QLXy9q5bVK869O9cuUJiau3je+K6DFo3WpDVZ6wRFl4swnl1p5vH4WUT5zQRMr+VbbCSYet6d2yprBI2EiIiJH2AkTERE5wk6YiIjIEc4JR2n9yBIR8/ouHmSlq8z+IdnNKRSK/G+xiYc++3cr7/v7xpr4izYvmXhglzutckUTvC02vNfUxBeWXGTltV/cz8QVD/6Y0Ncl35+925h4Uo1XHLaEgjY90t5Kl/zdjyuPzR9L9Io2rGfifaMPWnlVix0y8WcDOwRyknueCY+EiYiIHGEnTERE5AiHo3Mh7ZqZ+OM2L4bk+suQ1MwKKWpR4XX2nD+sdKuuA0y8sPV/TLyls708rMbsvL/2wav94c/Jbfwbf887kmaVq/gol6alQs1/rnbdBPLsuqWdiZcPGmvlNZjjT9NVtrPyrFi1qlZ603XVw5ardYV95asHqr1r4vmH7GVIvUf5V7mr+P28vDYxajwSJiIicoSdMBERkSPshImIiBzhnHAudrQubeKaxez5vuCdk4odlpS1qbDKXrbGSp/7oH8Z0aysiib+eOCTVrnLzhxm4rpDv0MkqmUjE29vV87Ke+Ue/wbfDUr4v1vrTx9slas3fwEo8YJLkoDolyV1GHqbietk8a5JyVZc2ZeWXd3Zv9Pc4g3+9+V18261yqlA3LHWzyZeu6eSVW52kykmLgJ76WE2JJDn1/jinppWuX6z/P+JhqO2WXkVt6RuHjiIR8JEgSVZiQAAAmFJREFURESOsBMmIiJyhMPRuTh8pj/EkR1yH5xn/2ho4ozxboYxCrMTK9ea+M3L/Jtxv/KqvZ0+u/JpE0/u0NLE773T1Sr32mB/DUWLtMj3PLpsVR8T139pv5XHOyWlXu33h5i4zt32kHM6Ik8/UGJkTPC/+9ofHGLl7ehxJOxz3mw3wUpfkOZ/zwbvXpRtDVTbS56yd9lXMKyVdSzsa5VY9LOVrrdvoYmPh31G6vFImIiIyBF2wkRERI5wODoXA3pFvtzSxGndTJwJDke7dHz9RhOn9TvLyhvS4i4TF7/vNxMvuuM5q1z96UMj1l/zI3+gOW32MhNnHzsac1spdulZ9rDypVnNTVwHPOs5vyj73vyQdPhyo3F+lDXa0z21sThCuchOxPyM1OORMBERkSPshImIiBxhJ0xEROQI54Rz8eEGf+5peEZyb+xMiXFi504rXfzzQPpzP+yJ1la5eojuale8NhoRJRKPhImIiBxhJ0xEROQIh6NzITP9GwM8UNW+iHzlhafDye9ERJSf8UiYiIjIEXbCREREjrATJiIicoRzwrmo/PxcE6943s4rFeWSFiIiokh4JExEROQIO2EiIiJHlAivAUREROQCj4SJiIgcYSdMRETkCDthIiIiR9gJExEROcJOmIiIyBF2wkRERI6wEyYiInKEnTAREZEj7ISJiIgcYSdMRETkCDthIiIiR9gJExEROcJOmIiIyBF2wkRERI6wEyYiInKEnTAREZEj7ISJiIgcYSdMRETkCDthIiIiR9gJExEROcJOmIiIyBF2wkRERI6wEyYiInLk/wGGZHgKBIJOfwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16],\n",
    "                keep_prob: 1.0\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(\n",
    "                np.argmax(mnist.test.labels[idx]), order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "卷积的特性\n",
    "卷积神经网络是在全连接神经网络的基础上改进，本质上仍然是层级网络。相比于全连接神经网络，卷积神经网络多了几层如卷积层，池化层。\n",
    "卷积神经网络通过对输入数据与卷积核进行卷积操作，缩小了特征的维度，只保留局部最明显特征。进过池化层，下采样进一步减少所要求的参数。\n",
    "最后将生成的特征图送入全连接神经网络进行分类。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "卷积神经网络分类效果优于全连接神经网络原因：\n",
    "1.\n",
    "全连接神经网络的参数数量太多 考虑一个输入1000* 1000像素的图片(一百万像素，现在已经不能算大图了)，输入层有1000* 1000=100万节点。\n",
    "假设第一个隐藏层有100个节点(这个数量并不多)，那么仅这一层就有(1000* 1000+1)* 100=1亿参数，这实在是太多了！我们看到图像只扩大一点，参数数量就会多很多，因此它的扩展性很差。而卷积神经网络采用局部连接，每个神经元不再和上一层的所有神经元相连，而只和一小部分神经元相连。这样就减少了很多参数。卷积神经网络采用权值共享 一组连接可以共享同一个权重，而不是每个连接有一个不同的权重，这样又减少了很多参数。池化层下采样，减少每层的样本数，进一步减少参数数量。\n",
    "2.\n",
    "全连接神经网络没有利用像素之间的位置信息 对于图像识别任务来说，每个像素和其周围像素的联系是比较紧密的，和离得很远的像素的联系可能就很小了。如果一个神经元和上一层所有神经元相连，那么就相当于对于一个像素来说，把图像的所有像素都等同看待，这不符合前面的假设。当我们完成每个连接权重的学习之后，最终可能会发现，有大量的权重，它们的值都是很小的(也就是这些连接其实无关紧要)。努力学习大量并不重要的权重，这样的学习必将是非常低效的。\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
